Why Go?

Go has simple syntax

• only 25 keywords (C - 35, Java - 50)
• only one loop type - for
• no fricking semicolons (;)
• no classes

package main

import "fmt"

func main() {
    for i := 0; i < 5; i++ {
        fmt.Println(i)
    }

    // while
    sum := 1
    for sum < 1000 {
        sum += sum
        fmt.Println(sum)
    }

    // forever
    // for {
    // }
}

Go doesn't break backwards compatibility

• 5 years
• 7 point versions
• no backwards incompatible changes in the API

No exception

• exceptions are slow
• piratically forces you to handle them

Protects developers from making mistakes

• no pointer arithmetics
• no functions that hide complexity
• no unused imports
• no unused variables

Fast compilation time

• clever dependency analysis
• compile-time error on unused dependencies
• can be used as interpreted language

Tool chain

• go run
• go get - works with github.com, no PyPi, RubyGems, npm
• go fmt - defines and enforces consistent style
• many more

go static analysis tools

• go vet
• go race detection

Static linking

• produces statically linked binaries
• runs in scratch containers

Cross compilation

Interfaces

• implicit (types doesn't need to say what they implement) - decouples the implementation packages from the packages that define the interfaces
• lightweight - only one or two methods, in fact the most common interface in the language has zero methods

Example from our own Miracl cryptography go implementations

• go/io

type Reader interface {
    Read(p []byte) (n int, err error)
}

func Copy(dst Writer, src Reader) (written int64, err error)
func CopyBuffer(dst Writer, src Reader, buf []byte) (written int64, err error)
func CopyN(dst Writer, src Reader, n int64) (written int64, err error)
func ReadAtLeast(r Reader, buf []byte, min int) (n int, err error)
func ReadFull(r Reader, buf []byte) (n int, err error)

Example from our own Miracl cryptography go implementations

type Rand struct {
    ...
}

// Returns random byte
func (rand *Rand) GetByte() byte {
    ...
}

// Implements io.Reader
func (rand *Rand) Read(p []byte) (n int, err error) {
    for x := 0; x < len(p); x++ {
        p[x] = rand.GetByte()
    }

    return len(p), nil
}

Example from our own Miracl cryptography go implementations

package main

import (
    "encoding/hex"
    "fmt"
    "io"

    "github.com/miracl/gomiracl"
    _ "github.com/miracl/gomiracl/go"
)

func main() {
    impl, _ := miracl.GetImpl(miracl.GO)
    seed, _ := hex.DecodeString("9e8b4178790cd57a5761c4a6f164ba72")
    rng := miracl.NewSeededRand(impl, seed)

    randomNum := make([]byte, 12)
    io.ReadFull(rng, randomNum)

    fmt.Println(randomNum)
}

Concurrency

• NOT parallelism
• goroutines and channels
• say 'go' and any function goes async
• no callbacks (if not needed)

Simple Producer-Consumer example

package main

import "fmt"

var msgs = make(chan int)
var done = make(chan bool)

func produce() {
    for i := 0; i < 10; i++ {
        msgs <- i
    }
    done <- true
}

func consume() {
    for {
        msg := <-msgs
        fmt.Println(msg)
    }
}

func main() {
    go produce()
    go consume()
    <-done
}

Is Go good for applications that have to be scalable?

• easy to write
• easy to read and maintain
• rich support for concurrency
• builds to a binary
• builds, starts and runs fast
• remember those scratch containers

Thank you